{
 "metadata": {
  "kernelspec": {
   "name": "python3",
   "display_name": "Python 3",
   "language": "python"
  },
  "language_info": {
   "name": "python",
   "version": "3.10.12",
   "mimetype": "text/x-python",
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "pygments_lexer": "ipython3",
   "nbconvert_exporter": "python",
   "file_extension": ".py"
  },
  "kaggle": {
   "accelerator": "gpu",
   "dataSources": [],
   "dockerImageVersionId": 30616,
   "isInternetEnabled": true,
   "language": "python",
   "sourceType": "notebook",
   "isGpuEnabled": true
  }
 },
 "nbformat_minor": 4,
 "nbformat": 4,
 "cells": [
  {
   "cell_type": "code",
   "source": [
    "import matplotlib as mpl\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "import numpy as np\n",
    "import sklearn\n",
    "import pandas as pd\n",
    "import os\n",
    "import sys\n",
    "import time\n",
    "from tqdm.auto import tqdm\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "\n",
    "print(sys.version_info)\n",
    "for module in mpl, np, pd, sklearn, torch:\n",
    "    print(module.__name__, module.__version__)\n",
    "    \n",
    "device = torch.device(\"cuda:0\") if torch.cuda.is_available() else torch.device(\"cpu\")\n",
    "print(device)\n",
    "\n",
    "seed = 42\n",
    "torch.manual_seed(seed)\n",
    "torch.cuda.manual_seed_all(seed)\n"
   ],
   "metadata": {
    "execution": {
     "iopub.status.busy": "2023-12-08T03:56:41.040886Z",
     "iopub.execute_input": "2023-12-08T03:56:41.041914Z",
     "iopub.status.idle": "2023-12-08T03:56:41.055773Z",
     "shell.execute_reply.started": "2023-12-08T03:56:41.041868Z",
     "shell.execute_reply": "2023-12-08T03:56:41.054673Z"
    },
    "trusted": true,
    "ExecuteTime": {
     "end_time": "2024-08-14T12:11:58.818894500Z",
     "start_time": "2024-08-14T12:11:48.778389600Z"
    }
   },
   "execution_count": 1,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sys.version_info(major=3, minor=12, micro=3, releaselevel='final', serial=0)\n",
      "matplotlib 3.9.0\n",
      "numpy 1.26.4\n",
      "pandas 2.2.2\n",
      "sklearn 1.5.0\n",
      "torch 2.3.1+cpu\n",
      "cpu\n"
     ]
    }
   ]
  },
  {
   "cell_type": "markdown",
   "source": [
    "# 准备数据"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "source": [
    "from tensorflow import keras\n",
    "#用karas有的数据集imdb，电影分类,分电影是积极的，还是消极的\n",
    "imdb = keras.datasets.imdb\n",
    "#载入数据使用下面两个参数\n",
    "vocab_size = 10000  #词典大小，仅保留训练数据中前10000个最经常出现的单词，低频单词被舍弃\n",
    "index_from = 3  #0,1,2,3空出来做别的事\n",
    "#前一万个词出现词频最高的会保留下来进行处理，后面的作为特殊字符处理，\n",
    "# 小于3的id都是特殊字符，下面代码有写\n",
    "# 需要注意的一点是取出来的词表还是从1开始的，需要做处理\n",
    "(train_data, train_labels), (test_data, test_labels) = imdb.load_data(\n",
    "    num_words = vocab_size, index_from = index_from)"
   ],
   "metadata": {
    "execution": {
     "iopub.status.busy": "2023-12-08T03:56:41.057859Z",
     "iopub.execute_input": "2023-12-08T03:56:41.058565Z",
     "iopub.status.idle": "2023-12-08T03:56:46.434050Z",
     "shell.execute_reply.started": "2023-12-08T03:56:41.058535Z",
     "shell.execute_reply": "2023-12-08T03:56:46.433226Z"
    },
    "trusted": true,
    "ExecuteTime": {
     "end_time": "2024-08-14T12:12:11.212512900Z",
     "start_time": "2024-08-14T12:11:58.825911200Z"
    }
   },
   "execution_count": 2,
   "outputs": []
  },
  {
   "cell_type": "code",
   "source": [
    "print(\"train\", train_data.shape, train_labels.shape)\n",
    "print(\"test\", test_data.shape, test_labels.shape)"
   ],
   "metadata": {
    "execution": {
     "iopub.status.busy": "2023-12-08T03:56:46.437383Z",
     "iopub.execute_input": "2023-12-08T03:56:46.437705Z",
     "iopub.status.idle": "2023-12-08T03:56:46.443644Z",
     "shell.execute_reply.started": "2023-12-08T03:56:46.437678Z",
     "shell.execute_reply": "2023-12-08T03:56:46.442614Z"
    },
    "trusted": true,
    "ExecuteTime": {
     "end_time": "2024-08-14T12:12:11.218099800Z",
     "start_time": "2024-08-14T12:12:11.214592500Z"
    }
   },
   "execution_count": 3,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train (25000,) (25000,)\n",
      "test (25000,) (25000,)\n"
     ]
    }
   ]
  },
  {
   "cell_type": "code",
   "source": [
    "#载入词表，看下词表长度，词表就像英语字典\n",
    "word_index = imdb.get_word_index()\n",
    "print(len(word_index))\n",
    "print(type(word_index))\n",
    "#词表虽然有8万多，但是我们只载入了最高频的1万词！！！！"
   ],
   "metadata": {
    "execution": {
     "iopub.status.busy": "2023-12-08T03:56:46.444961Z",
     "iopub.execute_input": "2023-12-08T03:56:46.445332Z",
     "iopub.status.idle": "2023-12-08T03:56:46.510542Z",
     "shell.execute_reply.started": "2023-12-08T03:56:46.445297Z",
     "shell.execute_reply": "2023-12-08T03:56:46.509651Z"
    },
    "trusted": true,
    "ExecuteTime": {
     "end_time": "2024-08-14T12:12:11.319115100Z",
     "start_time": "2024-08-14T12:12:11.220108500Z"
    }
   },
   "execution_count": 4,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "88584\n",
      "<class 'dict'>\n"
     ]
    }
   ]
  },
  {
   "cell_type": "markdown",
   "source": [
    "## 构造 word2idx 和 idx2word"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "source": [
    "word2idx = {word: idx + 3 for word, idx in word_index.items()}\n",
    "word2idx.update({\n",
    "    \"[PAD]\": 0,     # 填充 token\n",
    "    \"[BOS]\": 1,     # begin of sentence\n",
    "    \"[UNK]\": 2,     # 未知 token\n",
    "    \"[EOS]\": 3,     # end of sentence\n",
    "})\n",
    "\n",
    "idx2word = {idx: word for word, idx in word2idx.items()}"
   ],
   "metadata": {
    "execution": {
     "iopub.status.busy": "2023-12-08T03:56:46.513002Z",
     "iopub.execute_input": "2023-12-08T03:56:46.513314Z",
     "iopub.status.idle": "2023-12-08T03:56:46.555553Z",
     "shell.execute_reply.started": "2023-12-08T03:56:46.513267Z",
     "shell.execute_reply": "2023-12-08T03:56:46.554594Z"
    },
    "trusted": true,
    "ExecuteTime": {
     "end_time": "2024-08-14T12:12:11.373502700Z",
     "start_time": "2024-08-14T12:12:11.323113Z"
    }
   },
   "execution_count": 5,
   "outputs": []
  },
  {
   "cell_type": "code",
   "source": [
    "# 选择 max_length\n",
    "length_collect = {}\n",
    "for text in train_data:\n",
    "    length = len(text)\n",
    "    length_collect[length] = length_collect.get(length, 0) + 1\n",
    "    \n",
    "MAX_LENGTH = 500\n",
    "plt.bar(length_collect.keys(), length_collect.values())\n",
    "plt.axvline(MAX_LENGTH, label=\"max length\", c=\"gray\", ls=\":\")\n",
    "plt.legend()\n",
    "plt.show()"
   ],
   "metadata": {
    "execution": {
     "iopub.status.busy": "2023-12-08T03:56:46.556688Z",
     "iopub.execute_input": "2023-12-08T03:56:46.557006Z",
     "iopub.status.idle": "2023-12-08T03:56:48.567816Z",
     "shell.execute_reply.started": "2023-12-08T03:56:46.556979Z",
     "shell.execute_reply": "2023-12-08T03:56:48.566872Z"
    },
    "trusted": true,
    "ExecuteTime": {
     "end_time": "2024-08-14T12:12:12.784887900Z",
     "start_time": "2024-08-14T12:12:11.375503900Z"
    }
   },
   "execution_count": 6,
   "outputs": [
    {
     "data": {
      "text/plain": "<Figure size 640x480 with 1 Axes>",
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ]
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Tokenizer"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "source": [
    "class Tokenizer:\n",
    "    def __init__(self, word2idx, idx2word, max_length=500, pad_idx=0, bos_idx=1, eos_idx=3, unk_idx=2):\n",
    "        self.word2idx = word2idx\n",
    "        self.idx2word = idx2word\n",
    "        self.max_length = max_length\n",
    "        self.pad_idx = pad_idx\n",
    "        self.bos_idx = bos_idx\n",
    "        self.eos_idx = eos_idx\n",
    "        self.unk_idx = unk_idx\n",
    "    \n",
    "    def encode(self, text_list, padding_first=False):\n",
    "        \"\"\"如果padding_first == True，则padding加载前面，否则加载后面\"\"\"\n",
    "        max_length = min(self.max_length, 2 + max([len(text) for text in text_list]))\n",
    "        indices_list = []\n",
    "        for text in text_list:\n",
    "            indices = [self.bos_idx] + [self.word2idx.get(word, self.unk_idx) for word in text[:max_length-2]] + [self.eos_idx] #直接切片取前max_length-2个单词，然后加上bos和eos\n",
    "            if padding_first:\n",
    "                indices = [self.pad_idx] * (max_length - len(indices)) + indices\n",
    "            else:\n",
    "                indices = indices + [self.pad_idx] * (max_length - len(indices))\n",
    "            indices_list.append(indices)\n",
    "        return torch.tensor(indices_list)\n",
    "    \n",
    "    \n",
    "    def decode(self, indices_list, remove_bos=True, remove_eos=True, remove_pad=True, split=False):\n",
    "        text_list = []\n",
    "        for indices in indices_list:\n",
    "            text = []\n",
    "            for index in indices:\n",
    "                word = self.idx2word.get(index, \"[UNK]\")\n",
    "                if remove_bos and word == \"[BOS]\":\n",
    "                    continue\n",
    "                if remove_eos and word == \"[EOS]\":\n",
    "                    break\n",
    "                if remove_pad and word == \"[PAD]\":\n",
    "                    break\n",
    "                text.append(word)\n",
    "            text_list.append(\" \".join(text) if not split else text)\n",
    "        return text_list\n",
    "    \n",
    "\n",
    "tokenizer = Tokenizer(word2idx=word2idx, idx2word=idx2word)\n",
    "raw_text = [\"hello world\".split(), \"tokenize text datas with batch\".split(), \"this is a test\".split()]\n",
    "indices = tokenizer.encode(raw_text, padding_first=True)\n",
    "decode_text = tokenizer.decode(indices.tolist(), remove_bos=False, remove_eos=False, remove_pad=False)\n",
    "print(\"raw text\")\n",
    "for raw in raw_text:\n",
    "    print(raw)\n",
    "print(\"indices\")\n",
    "for index in indices:\n",
    "    print(index)\n",
    "print(\"decode text\")\n",
    "for decode in decode_text:\n",
    "    print(decode)"
   ],
   "metadata": {
    "execution": {
     "iopub.status.busy": "2023-12-08T03:56:48.569154Z",
     "iopub.execute_input": "2023-12-08T03:56:48.569535Z",
     "iopub.status.idle": "2023-12-08T03:56:48.597133Z",
     "shell.execute_reply.started": "2023-12-08T03:56:48.569501Z",
     "shell.execute_reply": "2023-12-08T03:56:48.596078Z"
    },
    "trusted": true,
    "ExecuteTime": {
     "end_time": "2024-08-14T12:12:12.842223200Z",
     "start_time": "2024-08-14T12:12:12.802885700Z"
    }
   },
   "execution_count": 7,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "raw text\n",
      "['hello', 'world']\n",
      "['tokenize', 'text', 'datas', 'with', 'batch']\n",
      "['this', 'is', 'a', 'test']\n",
      "indices\n",
      "tensor([   0,    0,    0,    1, 4825,  182,    3])\n",
      "tensor([    1,     2,  3004,     2,    19, 19233,     3])\n",
      "tensor([   0,    1,   14,    9,    6, 2181,    3])\n",
      "decode text\n",
      "[PAD] [PAD] [PAD] [BOS] hello world [EOS]\n",
      "[BOS] [UNK] text [UNK] with batch [EOS]\n",
      "[PAD] [BOS] this is a test [EOS]\n"
     ]
    }
   ]
  },
  {
   "cell_type": "code",
   "source": [
    "# 看看训练集的数据\n",
    "\n",
    "tokenizer.decode(train_data[:2], remove_bos=False, remove_eos=False, remove_pad=False)"
   ],
   "metadata": {
    "execution": {
     "iopub.status.busy": "2023-12-08T03:56:48.598454Z",
     "iopub.execute_input": "2023-12-08T03:56:48.598800Z",
     "iopub.status.idle": "2023-12-08T03:56:48.607972Z",
     "shell.execute_reply.started": "2023-12-08T03:56:48.598760Z",
     "shell.execute_reply": "2023-12-08T03:56:48.607067Z"
    },
    "trusted": true,
    "ExecuteTime": {
     "end_time": "2024-08-14T12:12:12.864847800Z",
     "start_time": "2024-08-14T12:12:12.845238800Z"
    }
   },
   "execution_count": 8,
   "outputs": [
    {
     "data": {
      "text/plain": "[\"[BOS] this film was just brilliant casting location scenery story direction everyone's really suited the part they played and you could just imagine being there robert [UNK] is an amazing actor and now the same being director [UNK] father came from the same scottish island as myself so i loved the fact there was a real connection with this film the witty remarks throughout the film were great it was just brilliant so much that i bought the film as soon as it was released for [UNK] and would recommend it to everyone to watch and the fly fishing was amazing really cried at the end it was so sad and you know what they say if you cry at a film it must have been good and this definitely was also [UNK] to the two little boy's that played the [UNK] of norman and paul they were just brilliant children are often left out of the [UNK] list i think because the stars that play them all grown up are such a big profile for the whole film but these children are amazing and should be praised for what they have done don't you think the whole story was so lovely because it was true and was someone's life after all that was shared with us all\",\n \"[BOS] big hair big boobs bad music and a giant safety pin these are the words to best describe this terrible movie i love cheesy horror movies and i've seen hundreds but this had got to be on of the worst ever made the plot is paper thin and ridiculous the acting is an abomination the script is completely laughable the best is the end showdown with the cop and how he worked out who the killer is it's just so damn terribly written the clothes are sickening and funny in equal [UNK] the hair is big lots of boobs [UNK] men wear those cut [UNK] shirts that show off their [UNK] sickening that men actually wore them and the music is just [UNK] trash that plays over and over again in almost every scene there is trashy music boobs and [UNK] taking away bodies and the gym still doesn't close for [UNK] all joking aside this is a truly bad film whose only charm is to look back on the disaster that was the 80's and have a good old laugh at how bad everything was back then\"]"
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ]
  },
  {
   "cell_type": "markdown",
   "source": [
    "## 数据集与 DataLoader"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "source": [
    "from torch.utils.data import Dataset, DataLoader\n",
    "\n",
    "class IMDBDataset(Dataset):\n",
    "    def __init__(self, data, labels, remain_length=True):\n",
    "        if remain_length:\n",
    "            self.data = tokenizer.decode(data, remove_bos=False, remove_eos=False, remove_pad=False)\n",
    "        else:\n",
    "            # 缩减一下数据\n",
    "            self.data = tokenizer.decode(data)\n",
    "        self.labels = labels\n",
    "    \n",
    "    def __getitem__(self, index):\n",
    "        text = self.data[index]\n",
    "        label = self.labels[index]\n",
    "        return text, label\n",
    "    \n",
    "    def __len__(self):\n",
    "        return len(self.data)\n",
    "    \n",
    "    \n",
    "def collate_fct(batch):\n",
    "    text_list = [item[0].split() for item in batch]\n",
    "    label_list = [item[1] for item in batch]\n",
    "    # 这里使用 padding first\n",
    "    text_list = tokenizer.encode(text_list, padding_first=True).to(dtype=torch.int)\n",
    "    return text_list, torch.tensor(label_list).reshape(-1, 1).to(dtype=torch.float)\n",
    "\n",
    "\n",
    "# 用RNN，缩短序列长度\n",
    "train_ds = IMDBDataset(train_data, train_labels, remain_length=False)\n",
    "test_ds = IMDBDataset(test_data, test_labels, remain_length=False)"
   ],
   "metadata": {
    "execution": {
     "iopub.status.busy": "2023-12-08T03:56:48.609141Z",
     "iopub.execute_input": "2023-12-08T03:56:48.609455Z",
     "iopub.status.idle": "2023-12-08T03:56:54.659024Z",
     "shell.execute_reply.started": "2023-12-08T03:56:48.609429Z",
     "shell.execute_reply": "2023-12-08T03:56:54.658211Z"
    },
    "trusted": true,
    "ExecuteTime": {
     "end_time": "2024-08-14T12:12:15.741358500Z",
     "start_time": "2024-08-14T12:12:12.860848600Z"
    }
   },
   "execution_count": 9,
   "outputs": []
  },
  {
   "cell_type": "code",
   "source": [
    "batch_size = 128\n",
    "train_dl = DataLoader(train_ds, batch_size=batch_size, shuffle=True, collate_fn=collate_fct)\n",
    "test_dl = DataLoader(test_ds, batch_size=batch_size, shuffle=False, collate_fn=collate_fct)"
   ],
   "metadata": {
    "execution": {
     "iopub.status.busy": "2023-12-08T03:56:54.660271Z",
     "iopub.execute_input": "2023-12-08T03:56:54.660748Z",
     "iopub.status.idle": "2023-12-08T03:56:54.675542Z",
     "shell.execute_reply.started": "2023-12-08T03:56:54.660707Z",
     "shell.execute_reply": "2023-12-08T03:56:54.674566Z"
    },
    "trusted": true,
    "ExecuteTime": {
     "end_time": "2024-08-14T12:12:15.748779800Z",
     "start_time": "2024-08-14T12:12:15.744356800Z"
    }
   },
   "execution_count": 10,
   "outputs": []
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([128, 500]) torch.Size([128, 1])\n"
     ]
    }
   ],
   "source": [
    "for text, label in train_dl:\n",
    "    print(text.shape, label.shape)\n",
    "    break"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-08-14T12:13:54.292225600Z",
     "start_time": "2024-08-14T12:13:54.191095900Z"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "# 定义模型"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "source": [
    "class RNN(nn.Module):\n",
    "    def __init__(self, embedding_dim=16, hidden_dim=64, vocab_size=vocab_size, num_layers=1, bidirectional=False):\n",
    "        super(RNN, self).__init__()\n",
    "        self.embeding = nn.Embedding(vocab_size, embedding_dim)\n",
    "        self.rnn = nn.RNN(embedding_dim, hidden_dim, num_layers=num_layers, batch_first=True, bidirectional=bidirectional)\n",
    "        self.layer = nn.Linear(hidden_dim * (2 if bidirectional else 1), hidden_dim)\n",
    "        self.fc = nn.Linear(hidden_dim, 1)\n",
    "        \n",
    "    def forward(self, x):\n",
    "        # [bs, seq length]\n",
    "        x = self.embeding(x)\n",
    "        # [bs, seq length, embedding_dim] -> shape [bs, embedding_dim, seq length]\n",
    "        seq_output, final_hidden = self.rnn(x)\n",
    "        # [bs, seq length, hidden_dim], [*, bs, hidden_dim]\n",
    "        x = seq_output[:, -1, :]\n",
    "        # 取最后一个时间步的输出 (这也是为什么要设置padding_first=True的原因)\n",
    "        x = self.layer(x)\n",
    "        x = self.fc(x)\n",
    "        return x\n",
    "    \n",
    "sample_inputs = torch.randint(0, vocab_size, (2, 128))\n",
    "    \n",
    "print(\"{:=^80}\".format(\" 一层单向 RNN \"))       \n",
    "for key, value in RNN().named_parameters():\n",
    "    print(f\"{key:^40}paramerters num: {np.prod(value.shape)}\")\n",
    "\n",
    "    \n",
    "print(\"{:=^80}\".format(\" 一层双向 RNN \"))       \n",
    "for key, value in RNN(bidirectional=True).named_parameters():\n",
    "    print(f\"{key:^40}paramerters num: {np.prod(value.shape)}\")\n",
    "\n",
    "    \n",
    "print(\"{:=^80}\".format(\" 俩层单向 RNN \"))       \n",
    "for key, value in RNN(num_layers=2).named_parameters():\n",
    "    print(f\"{key:^40}paramerters num: {np.prod(value.shape)}\")\n"
   ],
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-12-07T09:04:19.670302600Z",
     "start_time": "2023-12-07T09:04:19.597354800Z"
    },
    "execution": {
     "iopub.status.busy": "2023-12-08T03:56:54.680954Z",
     "iopub.execute_input": "2023-12-08T03:56:54.681375Z",
     "iopub.status.idle": "2023-12-08T03:56:54.704703Z",
     "shell.execute_reply.started": "2023-12-08T03:56:54.681337Z",
     "shell.execute_reply": "2023-12-08T03:56:54.703621Z"
    },
    "trusted": true
   },
   "execution_count": 47,
   "outputs": [
    {
     "name": "stdout",
     "text": "=================================== 一层单向 RNN ===================================\n            embeding.weight             paramerters num: 160000\n            rnn.weight_ih_l0            paramerters num: 1024\n            rnn.weight_hh_l0            paramerters num: 4096\n             rnn.bias_ih_l0             paramerters num: 64\n             rnn.bias_hh_l0             paramerters num: 64\n              layer.weight              paramerters num: 4096\n               layer.bias               paramerters num: 64\n               fc.weight                paramerters num: 64\n                fc.bias                 paramerters num: 1\n=================================== 一层双向 RNN ===================================\n            embeding.weight             paramerters num: 160000\n            rnn.weight_ih_l0            paramerters num: 1024\n            rnn.weight_hh_l0            paramerters num: 4096\n             rnn.bias_ih_l0             paramerters num: 64\n             rnn.bias_hh_l0             paramerters num: 64\n        rnn.weight_ih_l0_reverse        paramerters num: 1024\n        rnn.weight_hh_l0_reverse        paramerters num: 4096\n         rnn.bias_ih_l0_reverse         paramerters num: 64\n         rnn.bias_hh_l0_reverse         paramerters num: 64\n              layer.weight              paramerters num: 8192\n               layer.bias               paramerters num: 64\n               fc.weight                paramerters num: 64\n                fc.bias                 paramerters num: 1\n=================================== 俩层单向 RNN ===================================\n            embeding.weight             paramerters num: 160000\n            rnn.weight_ih_l0            paramerters num: 1024\n            rnn.weight_hh_l0            paramerters num: 4096\n             rnn.bias_ih_l0             paramerters num: 64\n             rnn.bias_hh_l0             paramerters num: 64\n            rnn.weight_ih_l1            paramerters num: 4096\n            rnn.weight_hh_l1            paramerters num: 4096\n             rnn.bias_ih_l1             paramerters num: 64\n             rnn.bias_hh_l1             paramerters num: 64\n              layer.weight              paramerters num: 4096\n               layer.bias               paramerters num: 64\n               fc.weight                paramerters num: 64\n                fc.bias                 paramerters num: 1\n",
     "output_type": "stream"
    }
   ]
  },
  {
   "cell_type": "markdown",
   "source": [
    "# 训练"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "source": [
    "from sklearn.metrics import accuracy_score\n",
    "\n",
    "@torch.no_grad()\n",
    "def evaluating(model, dataloader, loss_fct):\n",
    "    loss_list = []\n",
    "    pred_list = []\n",
    "    label_list = []\n",
    "    for datas, labels in dataloader:\n",
    "        datas = datas.to(device)\n",
    "        labels = labels.to(device)\n",
    "        # 前向计算\n",
    "        logits = model(datas)\n",
    "        loss = loss_fct(logits, labels)         # 验证集损失\n",
    "        loss_list.append(loss.item())\n",
    "        # 二分类\n",
    "        preds = logits > 0\n",
    "        pred_list.extend(preds.cpu().numpy().tolist())\n",
    "        label_list.extend(labels.cpu().numpy().tolist())\n",
    "        \n",
    "    acc = accuracy_score(label_list, pred_list)\n",
    "    return np.mean(loss_list), acc\n"
   ],
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-12-07T09:04:19.725273600Z",
     "start_time": "2023-12-07T09:04:19.673302600Z"
    },
    "execution": {
     "iopub.status.busy": "2023-12-08T03:56:54.705794Z",
     "iopub.execute_input": "2023-12-08T03:56:54.706059Z",
     "iopub.status.idle": "2023-12-08T03:56:54.713704Z",
     "shell.execute_reply.started": "2023-12-08T03:56:54.706035Z",
     "shell.execute_reply": "2023-12-08T03:56:54.712738Z"
    },
    "trusted": true
   },
   "execution_count": 48,
   "outputs": []
  },
  {
   "cell_type": "markdown",
   "source": [
    "### TensorBoard 可视化\n",
    "\n",
    "\n",
    "训练过程中可以使用如下命令启动tensorboard服务。\n",
    "\n",
    "```shell\n",
    "tensorboard \\\n",
    "    --logdir=runs \\     # log 存放路径\n",
    "    --host 0.0.0.0 \\    # ip\n",
    "    --port 8848         # 端口\n",
    "```"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "source": [
    "from torch.utils.tensorboard import SummaryWriter\n",
    "\n",
    "\n",
    "class TensorBoardCallback:\n",
    "    def __init__(self, log_dir, flush_secs=10):\n",
    "        \"\"\"\n",
    "        Args:\n",
    "            log_dir (str): dir to write log.\n",
    "            flush_secs (int, optional): write to dsk each flush_secs seconds. Defaults to 10.\n",
    "        \"\"\"\n",
    "        self.writer = SummaryWriter(log_dir=log_dir, flush_secs=flush_secs)\n",
    "\n",
    "    def draw_model(self, model, input_shape):\n",
    "        self.writer.add_graph(model, input_to_model=torch.randn(input_shape))\n",
    "        \n",
    "    def add_loss_scalars(self, step, loss, val_loss):\n",
    "        self.writer.add_scalars(\n",
    "            main_tag=\"training/loss\", \n",
    "            tag_scalar_dict={\"loss\": loss, \"val_loss\": val_loss},\n",
    "            global_step=step,\n",
    "            )\n",
    "        \n",
    "    def add_acc_scalars(self, step, acc, val_acc):\n",
    "        self.writer.add_scalars(\n",
    "            main_tag=\"training/accuracy\",\n",
    "            tag_scalar_dict={\"accuracy\": acc, \"val_accuracy\": val_acc},\n",
    "            global_step=step,\n",
    "        )\n",
    "        \n",
    "    def add_lr_scalars(self, step, learning_rate):\n",
    "        self.writer.add_scalars(\n",
    "            main_tag=\"training/learning_rate\",\n",
    "            tag_scalar_dict={\"learning_rate\": learning_rate},\n",
    "            global_step=step,\n",
    "            \n",
    "        )\n",
    "    \n",
    "    def __call__(self, step, **kwargs):\n",
    "        # add loss\n",
    "        loss = kwargs.pop(\"loss\", None)\n",
    "        val_loss = kwargs.pop(\"val_loss\", None)\n",
    "        if loss is not None and val_loss is not None:\n",
    "            self.add_loss_scalars(step, loss, val_loss)\n",
    "        # add acc\n",
    "        acc = kwargs.pop(\"acc\", None)\n",
    "        val_acc = kwargs.pop(\"val_acc\", None)\n",
    "        if acc is not None and val_acc is not None:\n",
    "            self.add_acc_scalars(step, acc, val_acc)\n",
    "        # add lr\n",
    "        learning_rate = kwargs.pop(\"lr\", None)\n",
    "        if learning_rate is not None:\n",
    "            self.add_lr_scalars(step, learning_rate)\n"
   ],
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-12-07T09:04:19.779322Z",
     "start_time": "2023-12-07T09:04:19.726271400Z"
    },
    "execution": {
     "iopub.status.busy": "2023-12-08T03:56:54.714985Z",
     "iopub.execute_input": "2023-12-08T03:56:54.715274Z",
     "iopub.status.idle": "2023-12-08T03:56:54.727971Z",
     "shell.execute_reply.started": "2023-12-08T03:56:54.715249Z",
     "shell.execute_reply": "2023-12-08T03:56:54.726997Z"
    },
    "trusted": true
   },
   "execution_count": 49,
   "outputs": []
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Save Best\n"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "source": [
    "class SaveCheckpointsCallback:\n",
    "    def __init__(self, save_dir, save_step=5000, save_best_only=True):\n",
    "        \"\"\"\n",
    "        Save checkpoints each save_epoch epoch. \n",
    "        We save checkpoint by epoch in this implementation.\n",
    "        Usually, training scripts with pytorch evaluating model and save checkpoint by step.\n",
    "\n",
    "        Args:\n",
    "            save_dir (str): dir to save checkpoint\n",
    "            save_epoch (int, optional): the frequency to save checkpoint. Defaults to 1.\n",
    "            save_best_only (bool, optional): If True, only save the best model or save each model at every epoch.\n",
    "        \"\"\"\n",
    "        self.save_dir = save_dir\n",
    "        self.save_step = save_step\n",
    "        self.save_best_only = save_best_only\n",
    "        self.best_metrics = -1\n",
    "        \n",
    "        # mkdir\n",
    "        if not os.path.exists(self.save_dir):\n",
    "            os.mkdir(self.save_dir)\n",
    "        \n",
    "    def __call__(self, step, state_dict, metric=None):\n",
    "        if step % self.save_step > 0:\n",
    "            return\n",
    "        \n",
    "        if self.save_best_only:\n",
    "            assert metric is not None\n",
    "            if metric >= self.best_metrics:\n",
    "                # save checkpoints\n",
    "                torch.save(state_dict, os.path.join(self.save_dir, \"best.ckpt\"))\n",
    "                # update best metrics\n",
    "                self.best_metrics = metric\n",
    "        else:\n",
    "            torch.save(state_dict, os.path.join(self.save_dir, f\"{step}.ckpt\"))\n",
    "\n"
   ],
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-12-07T09:04:19.791316800Z",
     "start_time": "2023-12-07T09:04:19.755336900Z"
    },
    "execution": {
     "iopub.status.busy": "2023-12-08T03:56:54.731416Z",
     "iopub.execute_input": "2023-12-08T03:56:54.731736Z",
     "iopub.status.idle": "2023-12-08T03:56:54.741180Z",
     "shell.execute_reply.started": "2023-12-08T03:56:54.731693Z",
     "shell.execute_reply": "2023-12-08T03:56:54.740443Z"
    },
    "trusted": true
   },
   "execution_count": 50,
   "outputs": []
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Early Stop"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "source": [
    "class EarlyStopCallback:\n",
    "    def __init__(self, patience=5, min_delta=0.01):\n",
    "        \"\"\"\n",
    "\n",
    "        Args:\n",
    "            patience (int, optional): Number of epochs with no improvement after which training will be stopped.. Defaults to 5.\n",
    "            min_delta (float, optional): Minimum change in the monitored quantity to qualify as an improvement, i.e. an absolute \n",
    "                change of less than min_delta, will count as no improvement. Defaults to 0.01.\n",
    "        \"\"\"\n",
    "        self.patience = patience\n",
    "        self.min_delta = min_delta\n",
    "        self.best_metric = -1\n",
    "        self.counter = 0\n",
    "        \n",
    "    def __call__(self, metric):\n",
    "        if metric >= self.best_metric + self.min_delta:\n",
    "            # update best metric\n",
    "            self.best_metric = metric\n",
    "            # reset counter \n",
    "            self.counter = 0\n",
    "        else: \n",
    "            self.counter += 1\n",
    "            \n",
    "    @property\n",
    "    def early_stop(self):\n",
    "        return self.counter >= self.patience\n"
   ],
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-12-07T09:04:19.791316800Z",
     "start_time": "2023-12-07T09:04:19.779322Z"
    },
    "execution": {
     "iopub.status.busy": "2023-12-08T03:56:54.742415Z",
     "iopub.execute_input": "2023-12-08T03:56:54.742724Z",
     "iopub.status.idle": "2023-12-08T03:56:54.753175Z",
     "shell.execute_reply.started": "2023-12-08T03:56:54.742698Z",
     "shell.execute_reply": "2023-12-08T03:56:54.752241Z"
    },
    "trusted": true
   },
   "execution_count": 51,
   "outputs": []
  },
  {
   "cell_type": "code",
   "source": [
    "# 训练\n",
    "def training(\n",
    "    model, \n",
    "    train_loader, \n",
    "    val_loader, \n",
    "    epoch, \n",
    "    loss_fct, \n",
    "    optimizer, \n",
    "    tensorboard_callback=None,\n",
    "    save_ckpt_callback=None,\n",
    "    early_stop_callback=None,\n",
    "    eval_step=500,\n",
    "    ):\n",
    "    record_dict = {\n",
    "        \"train\": [],\n",
    "        \"val\": []\n",
    "    }\n",
    "    \n",
    "    global_step = 0\n",
    "    model.train()\n",
    "    with tqdm(total=epoch * len(train_loader)) as pbar:\n",
    "        for epoch_id in range(epoch):\n",
    "            # training\n",
    "            for datas, labels in train_loader:\n",
    "                datas = datas.to(device)\n",
    "                labels = labels.to(device)\n",
    "                # 梯度清空\n",
    "                optimizer.zero_grad()\n",
    "                # 模型前向计算\n",
    "                logits = model(datas)\n",
    "                # 计算损失\n",
    "                loss = loss_fct(logits, labels)\n",
    "                # 梯度回传\n",
    "                loss.backward()\n",
    "                # 调整优化器，包括学习率的变动等\n",
    "                optimizer.step()\n",
    "                preds = logits > 0\n",
    "            \n",
    "                acc = accuracy_score(labels.cpu().numpy(), preds.cpu().numpy())    \n",
    "                loss = loss.cpu().item()\n",
    "                # record\n",
    "                \n",
    "                record_dict[\"train\"].append({\n",
    "                    \"loss\": loss, \"acc\": acc, \"step\": global_step\n",
    "                })\n",
    "                \n",
    "                # evaluating\n",
    "                if global_step % eval_step == 0:\n",
    "                    model.eval()\n",
    "                    val_loss, val_acc = evaluating(model, val_loader, loss_fct)\n",
    "                    record_dict[\"val\"].append({\n",
    "                        \"loss\": val_loss, \"acc\": val_acc, \"step\": global_step\n",
    "                    })\n",
    "                    model.train()\n",
    "                    \n",
    "                    # 1. 使用 tensorboard 可视化\n",
    "                    if tensorboard_callback is not None:\n",
    "                        tensorboard_callback(\n",
    "                            global_step, \n",
    "                            loss=loss, val_loss=val_loss,\n",
    "                            acc=acc, val_acc=val_acc,\n",
    "                            lr=optimizer.param_groups[0][\"lr\"],\n",
    "                            )\n",
    "                \n",
    "                    # 2. 保存模型权重 save model checkpoint\n",
    "                    if save_ckpt_callback is not None:\n",
    "                        save_ckpt_callback(global_step, model.state_dict(), metric=val_acc)\n",
    "\n",
    "                    # 3. 早停 Early Stop\n",
    "                    if early_stop_callback is not None:\n",
    "                        early_stop_callback(val_acc)\n",
    "                        if early_stop_callback.early_stop:\n",
    "                            print(f\"Early stop at epoch {epoch_id} / global_step {global_step}\")\n",
    "                            return record_dict\n",
    "                    \n",
    "                # udate step\n",
    "                global_step += 1\n",
    "                pbar.update(1)\n",
    "                pbar.set_postfix({\"epoch\": epoch_id})\n",
    "        \n",
    "    return record_dict\n",
    "        \n",
    "\n",
    "epoch = 20\n",
    "\n",
    "# model = RNN(bidirectional=True)\n",
    "# model = RNN(num_layers=2)\n",
    "model = RNN(bidirectional=True,num_layers=2)\n",
    "# 1. 定义损失函数 采用交叉熵损失 (但是二分类)\n",
    "loss_fct = F.binary_cross_entropy_with_logits\n",
    "# 2. 定义优化器 采用 adam\n",
    "# Optimizers specified in the torch.optim package\n",
    "optimizer = torch.optim.Adam(model.parameters(), lr=0.001)\n",
    "\n",
    "# 1. tensorboard 可视化\n",
    "if not os.path.exists(\"runs\"):\n",
    "    os.mkdir(\"runs\")\n",
    "tensorboard_callback = TensorBoardCallback(\"runs/imdb-rnn\")\n",
    "# tensorboard_callback.draw_model(model, [1, MAX_LENGTH])\n",
    "# 2. save best\n",
    "if not os.path.exists(\"checkpoints\"):\n",
    "    os.makedirs(\"checkpoints\")\n",
    "save_ckpt_callback = SaveCheckpointsCallback(\"checkpoints/imdb-rnn\", save_step=len(train_dl), save_best_only=True)\n",
    "# 3. early stop\n",
    "early_stop_callback = EarlyStopCallback(patience=10)\n",
    "\n",
    "model = model.to(device)\n",
    "record = training(\n",
    "    model, \n",
    "    train_dl, \n",
    "    test_dl, \n",
    "    epoch, \n",
    "    loss_fct, \n",
    "    optimizer, \n",
    "    tensorboard_callback=tensorboard_callback,\n",
    "    save_ckpt_callback=save_ckpt_callback,\n",
    "    early_stop_callback=early_stop_callback,\n",
    "    eval_step=len(train_dl)\n",
    "    )"
   ],
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-12-07T09:21:46.502713600Z",
     "start_time": "2023-12-07T09:04:19.791316800Z"
    },
    "execution": {
     "iopub.status.busy": "2023-12-08T03:56:54.754553Z",
     "iopub.execute_input": "2023-12-08T03:56:54.754886Z",
     "iopub.status.idle": "2023-12-08T04:02:37.889132Z",
     "shell.execute_reply.started": "2023-12-08T03:56:54.754861Z",
     "shell.execute_reply": "2023-12-08T04:02:37.888109Z"
    },
    "trusted": true
   },
   "execution_count": 52,
   "outputs": [
    {
     "output_type": "display_data",
     "data": {
      "text/plain": "  0%|          | 0/3920 [00:00<?, ?it/s]",
      "application/vnd.jupyter.widget-view+json": {
       "version_major": 2,
       "version_minor": 0,
       "model_id": "3f2505eded924e67aafa91abfee39e39"
      }
     },
     "metadata": {}
    }
   ]
  },
  {
   "cell_type": "code",
   "source": [
    "#画线要注意的是损失是不一定在零到1之间的\n",
    "def plot_learning_curves(record_dict, sample_step=500):\n",
    "    # build DataFrame\n",
    "    train_df = pd.DataFrame(record_dict[\"train\"]).set_index(\"step\").iloc[::sample_step]\n",
    "    val_df = pd.DataFrame(record_dict[\"val\"]).set_index(\"step\")\n",
    "\n",
    "    # plot\n",
    "    fig_num = len(train_df.columns)\n",
    "    fig, axs = plt.subplots(1, fig_num, figsize=(5 * fig_num, 5))\n",
    "    for idx, item in enumerate(train_df.columns):    \n",
    "        axs[idx].plot(train_df.index, train_df[item], label=f\"train_{item}\")\n",
    "        axs[idx].plot(val_df.index, val_df[item], label=f\"val_{item}\")\n",
    "        axs[idx].grid()\n",
    "        axs[idx].legend()\n",
    "        # axs[idx].set_xticks(range(0, train_df.index[-1], 5000))\n",
    "        # axs[idx].set_xticklabels(map(lambda x: f\"{int(x/1000)}k\", range(0, train_df.index[-1], 5000)))\n",
    "        axs[idx].set_xlabel(\"step\")\n",
    "    \n",
    "    plt.show()\n",
    "\n",
    "plot_learning_curves(record, sample_step=10)  #横坐标是 steps"
   ],
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-12-07T09:21:48.454603700Z",
     "start_time": "2023-12-07T09:21:46.509709300Z"
    },
    "execution": {
     "iopub.status.busy": "2023-12-08T04:02:37.890371Z",
     "iopub.execute_input": "2023-12-08T04:02:37.890648Z",
     "iopub.status.idle": "2023-12-08T04:02:38.263775Z",
     "shell.execute_reply.started": "2023-12-08T04:02:37.890625Z",
     "shell.execute_reply": "2023-12-08T04:02:38.262830Z"
    },
    "trusted": true
   },
   "execution_count": 53,
   "outputs": [
    {
     "output_type": "display_data",
     "data": {
      "text/plain": "<Figure size 1000x500 with 2 Axes>",
      "image/png": "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"
     },
     "metadata": {}
    }
   ]
  },
  {
   "cell_type": "markdown",
   "source": [
    "# 评估"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "source": [
    "# dataload for evaluating\n",
    "\n",
    "# load checkpoints\n",
    "model.load_state_dict(torch.load(\"checkpoints/imdb-rnn/best.ckpt\", map_location=\"cpu\"))\n",
    "\n",
    "model.eval()\n",
    "loss, acc = evaluating(model, test_dl, loss_fct)\n",
    "print(f\"loss:     {loss:.4f}\\naccuracy: {acc:.4f}\")"
   ],
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-12-07T09:22:04.587411800Z",
     "start_time": "2023-12-07T09:21:48.456602300Z"
    },
    "execution": {
     "iopub.status.busy": "2023-12-08T04:02:38.265426Z",
     "iopub.execute_input": "2023-12-08T04:02:38.265820Z",
     "iopub.status.idle": "2023-12-08T04:02:45.859021Z",
     "shell.execute_reply.started": "2023-12-08T04:02:38.265777Z",
     "shell.execute_reply": "2023-12-08T04:02:45.858108Z"
    },
    "trusted": true
   },
   "execution_count": 54,
   "outputs": [
    {
     "name": "stdout",
     "text": "loss:     0.4738\naccuracy: 0.7816\n",
     "output_type": "stream"
    }
   ]
  }
 ]
}
